home *** CD-ROM | disk | FTP | other *** search
/ Chip 1996 September / CHIP Eylül 1996.iso / utils / povray / povppc.sit / POVPPC / SOURCE / ImageWindow.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-25  |  39.7 KB  |  1,545 lines
  1. /*==============================================================================
  2. Project:    POV-Ray
  3.  
  4. Version:    2.2
  5.  
  6. File:    ImageWindow.c
  7.  
  8. Description:
  9.     This file contains the Macintosh Image window routines for POV-Ray.
  10. ------------------------------------------------------------------------------
  11. Authors:
  12.     Jim Nitchals, David Harr, Eduard [esp] Schwan
  13. ------------------------------------------------------------------------------
  14.     from Persistence of Vision Raytracer
  15.     Copyright 1993 Persistence of Vision Team
  16. ------------------------------------------------------------------------------
  17.     NOTICE: This source code file is provided so that users may experiment
  18.     with enhancements to POV-Ray and to port the software to platforms other 
  19.     than those supported by the POV-Ray Team.  There are strict rules under
  20.     which you are permitted to use this file.  The rules are in the file
  21.     named POVLEGAL.DOC which should be distributed with this file. If 
  22.     POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  23.     Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  24.     Forum.  The latest version of POV-Ray may be found there as well.
  25.  
  26.     This program is based on the popular DKB raytracer version 2.12.
  27.     DKBTrace was originally written by David K. Buck.
  28.     DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  29. ------------------------------------------------------------------------------
  30. More Info:
  31.     This Macintosh version of POV-Ray was created and compiled by Jim Nitchals
  32.     (Think 5.0) and Eduard Schwan (MPW 3.2), based (loosely) on the original
  33.     port by Thomas Okken and David Lichtman, with some help from Glenn Sugden.
  34.  
  35.     For bug reports regarding the Macintosh version, you should contact:
  36.     Eduard [esp] Schwan
  37.         CompuServe: 71513,2161
  38.         Internet: jl.tech@applelink.apple.com
  39.         AppleLink: jl.tech
  40.     Jim Nitchals
  41.         Compuserve: 73117,3020
  42.         America Online: JIMN8
  43.         Internet: jimn8@aol.com -or- jimn8@applelink.apple.com
  44.         AppleLink: JIMN8
  45. ------------------------------------------------------------------------------
  46. Change History:
  47.     930610    [esp]    Created
  48.     930610    [esp]    Added Size2Window code
  49.     930620    [esp]    Changed brighten/darken image slightly to fix saturation bug
  50.     930710    [esp]    Added WindowValid check
  51.     930903    [esp]    Major bug fixes to Virtual Image Buffer code
  52.     931001    [esp]    version 2.0 finished (Released on 10/4/93)
  53.     931119    [djh]    2.0.1 source conditionally compiles for PPC machines, keyword __powerc
  54.     940416    [PFS]    2.2.1 greatly reworked to clean up PPC support and provide CodeWarrior projects
  55. ==============================================================================*/
  56.  
  57. /*==== our header ====*/
  58. #include "ImageWindow.h"
  59.  
  60.  
  61. /*==== defs ====*/
  62.  
  63. // temp virtual image file file
  64. #define    POVRAY_IMAGETEMP_FNAME    "POV-Ray.vib"
  65.  
  66. // Windows
  67. #define    kWindID_Image            1001    // image window
  68.  
  69.  
  70. #define    PICTF_HEADER_SIZE        512        // old MacDraw PICTF header
  71.  
  72. /* Pict file header structure (after the 512 byte header) */
  73. typedef struct
  74. {
  75.     short        picSize;        // low word of size
  76.     Rect        picFrame;        // picture bounds
  77. } PictFHeader, *PictFHeaderPtr;
  78.  
  79.  
  80. /*==== globals ====*/
  81.  
  82. WindowPtr        gImageWindowPtr = NULL;        // the image window
  83. Boolean            gImageWindIsValid = false;    // true if valid stuff in window
  84. // Str63            gImageWindName;                // image window's name
  85. Boolean            use_custom_palette = false;    // does the user desire to use color q?
  86. int                gColorQuantMethod = -1;        // what kind of color quantization?
  87. Boolean            gDoingVirtualFile = false;    // true if doing virtual image buffering
  88.  
  89. #if defined(__powerc)
  90. extern RoutineDescriptor MyPutPicProc;
  91. #endif
  92.  
  93. // Forward declaration of function
  94. pascal void MyPutPicProcProc( char *dataPtr, short byteCount);
  95.  
  96. /*==== globals (local) ====*/
  97.  
  98. /* image window stuff */
  99. static PixMapHandle    gOffScreenPixMapH = NULL;
  100. static Ptr            gImagePixmapPtr = NULL;
  101. static CTabHandle    gCTabHdl = NULL;
  102.  
  103. static PaletteHandle    gCustomPalette = NULL;
  104. static PaletteHandle    gSystemPalette = NULL;
  105.  
  106. // used by Paint_to_Picture() and MyPutPicProc()
  107. PicHandle            gMyPicHandle;
  108. long                gMyPicSize;
  109.  
  110. static FILE            *gImagePictFile = NULL; // used to save image to PICT
  111. static Rect            gImageBounds,        // source (offscreen image) bounds
  112.                     gDisplayBounds;        // destination image bounds
  113. static short        gImageWidth,
  114.                     gImageHeight;
  115. static int            gLastYPos = 0;        // last vertical position during previous refresh
  116. static short        gCurrYPos;
  117. static long            gPixMapBuffSize;
  118. static long            gDitherTicks;        // # of ticks to wait between image refresh
  119. static long            gRefreshTick = 0;    // Time of last Quickdraw dither of graphic port
  120.  
  121. /* Undo stuff */
  122. static Ptr            gImageUndoBuffer = NULL;
  123. static Ptr            gImageUndoBuffer2 = NULL;
  124. static Ptr            gImageRevertBuffer = NULL;
  125.  
  126. /* virtual image buffer globals */
  127. static FILE            *gVirtualImageFile = NULL;
  128. static short        virtual_pixHeight;
  129. static short        virtual_buffer_dirty;
  130. static short        virtual_currentSegment = -1;
  131. static short        virtual_minY;
  132. static short        virtual_maxY;
  133. static long            virtual_segSize = SWAP_SIZE;
  134.  
  135.  
  136. // ==============================================
  137. void InitImageWindow(void)
  138. {
  139.     // allocate the image window (it is shown/hidden later)
  140.     gImageWindowPtr = GetNewCWindow(kWindID_Image, NULL, (WindowPtr)NULL);
  141. } // InitImageWindow
  142.  
  143.  
  144. // ==============================================
  145. void KillImageWindow(void)
  146. {
  147.     if (gImageWindowPtr)
  148.         DisposeWindow(gImageWindowPtr);
  149.     gImageWindowPtr = NULL;
  150. } // KillImageWindow
  151.  
  152.  
  153.  
  154. // ==============================================
  155. // Create system/custom palette variables for use by image window
  156. void SetupPalettes(void)
  157. {
  158.     int        k;
  159.  
  160.     // Get default System palette for non-custom mode, (IM VI, Pg. 20-17)
  161.     gSystemPalette = NewPalette(256, NULL, pmTolerant, 0x0000);
  162.     if (gSystemPalette)
  163.     {
  164.         CopyPalette(GetPalette((WindowPtr)-1), gSystemPalette, 0, 0, 256);
  165.         for (k=0; k<256; k++)
  166.             SetEntryUsage(gSystemPalette, k, pmTolerant, 0x0000);
  167.     }
  168.  
  169.     // allocate a palette for the Image window, fill to default system palette
  170.     gCustomPalette = NewPalette(256, NULL, pmTolerant, 0x0000); // exact match only
  171.     if (gCustomPalette)
  172.     {
  173.         CopyPalette(gSystemPalette, gCustomPalette, 0, 0, 256);
  174.         for (k=0; k<256; k++)
  175.             SetEntryUsage(gCustomPalette, k, pmTolerant, 0x0000);
  176.     }
  177. } // SetupPalettes
  178.  
  179.  
  180. // ==============================================
  181. // Build offscreen pixmap
  182. void SetupOffscreen(void)
  183. {
  184.     // Jim, since we REQUIRE 32 bit Color QuickDraw, we should change this
  185.     // to use the much easier and better supported 32bQD call NewGWorld()? [esp]
  186.     gCTabHdl                = (CTabHandle) NewHandle(sizeof(ColorTable));
  187.     (**gCTabHdl).ctSeed        = 24;
  188.     (**gCTabHdl).ctFlags    = 0;
  189.     (**gCTabHdl).ctSize        = 0;
  190.     gOffScreenPixMapH        = (PixMapHandle) NewHandle(sizeof(PixMap));
  191.     if (gOffScreenPixMapH != NULL)
  192.     {
  193.         (**gOffScreenPixMapH).pmVersion        = 0;
  194.         (**gOffScreenPixMapH).packType        = 0;
  195.         (**gOffScreenPixMapH).packSize        = 0;
  196.         (**gOffScreenPixMapH).hRes            = 0x480000;    // 72.0 x 72.0 dpi
  197.         (**gOffScreenPixMapH).vRes            = 0x480000;
  198.         (**gOffScreenPixMapH).pixelType        = RGBDirect;
  199.         (**gOffScreenPixMapH).pixelSize        = 32;
  200.         (**gOffScreenPixMapH).cmpCount        = 3;
  201.         (**gOffScreenPixMapH).cmpSize        = 8;
  202.         (**gOffScreenPixMapH).planeBytes    = 0;
  203.         (**gOffScreenPixMapH).pmTable        = gCTabHdl;
  204.         (**gOffScreenPixMapH).pmReserved    = 0;
  205.         (**gOffScreenPixMapH).baseAddr        = NULL;
  206.     }
  207.     
  208.     if (gOffScreenPixMapH == NULL)
  209.     {
  210.         // fatal error
  211.         displayDialog(kdlog_GenericFatalErr, "Cannot allocate memory for PixMap",
  212.                     MemError(), ewcDoCentering, eMainDevice);
  213.         exit_handler();
  214.     }
  215. } // SetupOffscreen
  216.  
  217.  
  218. // ==============================================
  219. // Build offscreen pixmap
  220. void KillOffscreen(void)
  221. {
  222.     if (gCTabHdl)
  223.         DisposeHandle((Handle)gCTabHdl);
  224.     if (gOffScreenPixMapH)
  225.         DisposeHandle((Handle)gOffScreenPixMapH);
  226.     gCTabHdl = NULL;
  227.     gOffScreenPixMapH = NULL;
  228. } // KillOffscreen
  229.  
  230.  
  231. // ==============================================
  232. // Close the image window
  233. void CloseImageWindow()
  234. {
  235.     if (gImageWindowPtr)
  236.         HideWindow(gImageWindowPtr);
  237.     (**gFilePrefs_h).imageMagFactor = viewmn_hidden;
  238. } // CloseImageWindow
  239.  
  240.  
  241. // ==============================================
  242. // Force the entire image window to be updated
  243. void InvalRect_ImageWindow(Boolean DoWholeWindow)
  244. {
  245.     int        magFactor;
  246.     Rect    myInvalRect;
  247.  
  248.     if (gImageWindowPtr && ((WindowPeek)gImageWindowPtr)->visible)
  249.     {
  250.         SetPort(gImageWindowPtr);
  251.  
  252.         myInvalRect = gImageWindowPtr->portRect;
  253.         ClipRect(&myInvalRect);
  254.  
  255.         // if doing partial window in a regular magnification mode...
  256.         if (!DoWholeWindow && ((**gPrefs2Use_h).imageMagFactor != viewmn_Size2Window))
  257.         {
  258.             magFactor = (**gPrefs2Use_h).imageMagFactor-viewmn_normal+1; // 1,2,3,4
  259.             myInvalRect.top = magFactor * gLastYPos;
  260.             myInvalRect.bottom = magFactor * (gCurrYPos + 1);
  261.         }
  262.  
  263.         InvalRect(&myInvalRect);
  264.     }
  265. } // InvalRect_ImageWindow
  266.  
  267.  
  268. // ==============================================
  269. // Display the image window grow box
  270. static void DrawImageGrowBox(void)
  271. {
  272.     int            looper;
  273.     Rect        box;
  274.     PenState    pstate;
  275.  
  276.     // Save current port state
  277.     SetPort(gImageWindowPtr);
  278.     GetPenState(&pstate);
  279.  
  280.     // find window size
  281.     box = gImageWindowPtr->portRect;
  282.  
  283.     // make boxes in lower left corner
  284.     box.top = box.bottom-7;
  285.     box.left = box.right-7;
  286.     OffsetRect(&box, -1, -1);
  287.  
  288.     // do two overlapping boxes
  289.     for (looper=0; looper<2; looper++)
  290.     {
  291.         // draw white box
  292.         ForeColor(whiteColor);
  293.         FrameRect(&box);
  294.  
  295.         // draw black box
  296.         OffsetRect(&box, -1, -1);
  297.         ForeColor(blackColor);
  298.         FrameRect(&box);
  299.  
  300.         // move up & draw 2nd smaller box
  301.         OffsetRect(&box, -2, -2);
  302.         box.right    -= 1;
  303.         box.bottom    -= 1;
  304.     }
  305.  
  306.     // restore world
  307.     SetPenState(&pstate);
  308. } // DrawImageGrowBox
  309.  
  310.  
  311. // ==============================================
  312. void DoResizeImageWindow(WindowPtr w, short h, short v)
  313. {
  314. //    Rect    oldHorizBar;
  315.     Rect     r;
  316.     
  317.     SetPort(w);
  318.  
  319. //    oldHorizBar = w->portRect;
  320. //    oldHorizBar.top = oldHorizBar.bottom - (SBarWidth+1);
  321.  
  322.     SizeWindow(w, h, v, false);
  323.  
  324. //    EraseRect(&oldHorizBar);
  325.     
  326. //    MoveControl(gSrcWind_VScroll, w->portRect.right - SBarWidth, w->portRect.top-1);
  327. //    SizeControl(gSrcWind_VScroll, SBarWidth+1, w->portRect.bottom - w->portRect.top-(SBarWidth-2));
  328. //    r = (**gSrcWind_VScroll).contrlRect;
  329. //    ValidRect(&r);
  330.  
  331.     GetGlobalWindowRect(w, &r);
  332.     (**gFilePrefs_h).imageWind_pos = r;
  333.     if ((**gPrefs2Use_h).imageMagFactor == viewmn_Size2Window)
  334.         gDisplayBounds = w->portRect;
  335.  
  336. } // DoResizeImageWindow
  337.  
  338.  
  339. // ==============================================
  340. void DoGrowImageWindow(WindowPtr w, Point p)
  341. {
  342.     GrafPtr        savePort;
  343.     long        theResult;
  344.     Rect        r;
  345.     
  346.     GetPort(&savePort);
  347.     SetPort(w);
  348.  
  349.     GetMaxGrowRect(w, &r);    
  350.     theResult = GrowWindow(w, p, &r);
  351.     if (theResult != 0)
  352.     {
  353.         DoResizeImageWindow(w, LoWord(theResult), HiWord(theResult));
  354.         InvalRect_ImageWindow(true);
  355.     }
  356.  
  357.     SetPort(savePort);
  358. } // DoGrowImageWindow
  359.  
  360.  
  361. // ==============================================
  362. void UpdateImageWindow(void)
  363. {
  364.     if (gImageWindowPtr)
  365.     {
  366.         SetPort(gImageWindowPtr);
  367.         BeginUpdate(gImageWindowPtr);
  368.         DrawImageWindow(false);
  369.         EndUpdate(gImageWindowPtr);
  370.     }
  371. } // UpdateImageWindow
  372.  
  373.  
  374. // ==============================================
  375. void SetImageWindowMag(short magMenuItem)
  376. {
  377.     int            magFactor;
  378.     Rect        r,screenRect;
  379.     GDHandle    theGD;
  380.  
  381.     if (magMenuItem == viewmn_hidden)
  382.         HideWindow(gImageWindowPtr);
  383.     else
  384.     {
  385.         if (magMenuItem == viewmn_Size2Window)
  386.         { // set image buffer to 1xsize, leave window size alone
  387.             gDisplayBounds = gImageWindowPtr->portRect;
  388.         }
  389.         else
  390.         { // set image buffer rect to N*Size, resize window
  391.             magFactor = magMenuItem-viewmn_normal+1; // 1,2,3,4
  392.             // get new zero-based rect
  393.             SetRect(&gDisplayBounds, 0, 0,
  394.                         gImageWidth * magFactor,
  395.                         gImageHeight * magFactor);
  396.             // convert to potential global window rect
  397.             GetGlobalWindowRect(gImageWindowPtr, &r);
  398.             r.right = r.left + gDisplayBounds.right;
  399.             r.bottom = r.top + gDisplayBounds.bottom;
  400.             // move it to appropriate screen if needed
  401.             ForceRectOnScreen(&r);
  402. // [esp] hmm, shouldn't this next useful chunk of code be moved into ScreenUtils.c?
  403.             // clip any overhang off bottom/right
  404.             theGD = GetClosestGDevice(&r);
  405.             screenRect = (**theGD).gdRect;
  406.             if (r.right > screenRect.right)
  407.                 r.right = screenRect.right;
  408.             if (r.bottom > screenRect.bottom)
  409.                 r.bottom = screenRect.bottom;
  410.             MoveWindow(gImageWindowPtr, r.left, r.top, false);
  411.             DoResizeImageWindow(gImageWindowPtr,
  412.                         r.right-r.left,
  413.                         r.bottom-r.top);
  414. // [esp] need code here to handle scroll bars... oh yah, we need scroll bars first!
  415.         }
  416.  
  417.         // if window is valid, show it now.  This check lets the user
  418.         // set the window size even when there's no valid window content,
  419.         // and doesn't actually show the window until it is valid.
  420.         if (gImageWindIsValid)
  421.         {
  422.             ShowWindow(gImageWindowPtr);
  423.             SelectWindow(gImageWindowPtr);
  424.             InvalRect_ImageWindow(true);
  425.         }
  426.     } // else visible
  427. } // SetImageWindowMag
  428.  
  429.  
  430. // ==============================================
  431. // Create undo buffers for Image window changes
  432. void make_undo(void)
  433. {
  434.     if (gImageUndoBuffer == 0)
  435.     {
  436.         gImageUndoBuffer = NewPtr (gPixMapBuffSize);    /* room for image */
  437.         gImageUndoBuffer2 = NewPtr (gPixMapBuffSize);    /* room for image */
  438.         gImageRevertBuffer = NewPtr (gPixMapBuffSize);
  439.         if ( (gImageRevertBuffer) && (gImagePixmapPtr))
  440.             memcpy(gImageRevertBuffer, gImagePixmapPtr, gPixMapBuffSize);
  441.     }
  442.  
  443.     /* if any of the memory allocations failed, or available mem is low, */
  444.     /* fail the whole undo system */
  445.     if ( (gImageUndoBuffer == NULL) || (gImageUndoBuffer2 == NULL) || (gImageRevertBuffer == NULL)
  446.     || (FreeMem() < 50000L) )
  447.     {
  448.         if (gImageUndoBuffer)
  449.             DisposePtr (gImageUndoBuffer);
  450.         if (gImageUndoBuffer2)
  451.             DisposePtr (gImageUndoBuffer2);
  452.         if (gImageRevertBuffer)
  453.             DisposePtr (gImageRevertBuffer);
  454.         gImageUndoBuffer = NULL;
  455.         gImageUndoBuffer2 = NULL;
  456.         gImageRevertBuffer = NULL;
  457.     }
  458.  
  459.     if ((gImageUndoBuffer) && (gImagePixmapPtr))
  460.     {
  461.         memcpy(gImageUndoBuffer, gImagePixmapPtr, gPixMapBuffSize);
  462.         gCanUndo = TRUE;
  463.     }
  464. } // make_undo
  465.  
  466.  
  467. // ==============================================
  468. // Actually do the undo operation on the image window
  469. void undo_image(void)
  470. {
  471.     if ((gImageUndoBuffer) && (gCanUndo) && (gImagePixmapPtr))
  472.     {
  473.         memcpy(gImageUndoBuffer2, gImagePixmapPtr, gPixMapBuffSize);
  474.         memcpy(gImagePixmapPtr, gImageUndoBuffer, gPixMapBuffSize);
  475.         memcpy(gImageUndoBuffer, gImageUndoBuffer2, gPixMapBuffSize);
  476.         InvalRect_ImageWindow(true);
  477.     }
  478. } // undo_image
  479.  
  480.  
  481. // ==============================================
  482. // restore the original image to the image window
  483. void revert_image(void)
  484. {
  485.     if ((gImageRevertBuffer) && (gImagePixmapPtr))
  486.     {
  487.         memcpy(gImageUndoBuffer, gImagePixmapPtr, gPixMapBuffSize);
  488.         memcpy(gImagePixmapPtr, gImageRevertBuffer, gPixMapBuffSize);
  489.         gCanUndo = TRUE;
  490.         InvalRect_ImageWindow(true);
  491.     }
  492. } // revert_image
  493.  
  494.  
  495. // ==============================================
  496. // return the value "v", insuring it is between 0 and 255
  497. static short ClipToByteRange(short v)
  498. {
  499.     if ( v < 0)
  500.         return (0);
  501.     if (v > 255)
  502.         return (255);
  503.     return (v);
  504. } // ClipToByteRange
  505.  
  506.  
  507. // ==============================================
  508. // Darken every pixel value in image window by 7/8ths original
  509. void darken_image(void)
  510. {
  511.     unsigned char *pptr;
  512.     short        v;
  513.     long        i,j;
  514.     
  515.     make_undo();
  516.     if (gImagePixmapPtr == 0) return;
  517.  
  518.     for (i=0; i < gImageHeight; i++)
  519.     {
  520.         for (j=0; j < gImageWidth; j++)
  521.         {
  522.             pptr = (unsigned char *) 
  523.                     (gImagePixmapPtr + 4L * ((gImageWidth * i) + j));
  524.             *pptr = 0;
  525.             pptr++;
  526.             v = (*pptr * 7 / 8)-1;
  527.             *pptr = ClipToByteRange (v);
  528.             pptr++;
  529.             v = (*pptr * 7 / 8)-1;
  530.             *pptr = ClipToByteRange (v);
  531.             pptr++;
  532.             v = (*pptr * 7 / 8)-1;
  533.             *pptr = ClipToByteRange (v);
  534.             pptr++;
  535.         }
  536.     }
  537.     InvalRect_ImageWindow(true);
  538. } // darken_image
  539.  
  540.  
  541. // ==============================================
  542. // Lighten every pixel value in image window by 8/7ths original
  543. void lighten_image(void)
  544. {
  545.     unsigned char *pptr;
  546.     long i,j;
  547.     short v;
  548.  
  549.     make_undo();
  550.     if (gImagePixmapPtr == 0) return;
  551.  
  552.     for (i=0; i < gImageHeight; i++)
  553.     {
  554.         for (j=0; j < gImageWidth; j++)
  555.         {
  556.             pptr = (unsigned char *) 
  557.                     (gImagePixmapPtr + 4L * ((gImageWidth * i) + j));
  558.             *pptr = 0;
  559.             pptr++;
  560.             v = (*pptr * 8 / 7)+1;
  561.             *pptr = ClipToByteRange (v);
  562.             pptr++;
  563.             v = (*pptr * 8 / 7)+1;
  564.             *pptr = ClipToByteRange (v);
  565.             pptr++;
  566.             v = (*pptr * 8 / 7)+1;
  567.             *pptr = ClipToByteRange (v);
  568.             pptr++;
  569.         }
  570.     }
  571.     InvalRect_ImageWindow(true);
  572. } // lighten_image
  573.  
  574.  
  575. // ==============================================
  576. // Invert every pixel value in image window
  577. void invert_image(void)
  578. {
  579.     unsigned char *pptr;
  580.     long i,j;
  581.     
  582.     make_undo();
  583.     if (gImagePixmapPtr == 0) return;
  584.  
  585.     for (i=0; i < gImageHeight; i++)
  586.     {
  587.         for (j=0; j < gImageWidth; j++)
  588.         {
  589.             pptr = (unsigned char *) 
  590.                     (gImagePixmapPtr + 4L * ((gImageWidth * i) + j));
  591.             *pptr = 0;
  592.             pptr++;
  593.             *pptr = 255 - *pptr;
  594.             pptr++;
  595.             *pptr = 255 - *pptr;
  596.             pptr++;
  597.             *pptr = 255 - *pptr;
  598.             pptr++;
  599.         }
  600.     }
  601.     InvalRect_ImageWindow(true);
  602. } // invert_image
  603.  
  604.  
  605. // ==============================================
  606. // Reduce the contrast of every pixel value in image window a bit
  607. void reduce_contrast(void)
  608. {
  609.     unsigned char *pptr;
  610.     long i,j;
  611.     short v;
  612.     
  613.     make_undo();
  614.     if (gImagePixmapPtr == 0) return;
  615.  
  616.     for (i=0; i < gImageHeight; i++)
  617.     {
  618.         for (j=0; j < gImageWidth; j++)
  619.         {
  620.             pptr = (unsigned char *) 
  621.                     (gImagePixmapPtr + 4L * ((gImageWidth * i) + j));
  622.             *pptr++ = 0;
  623.  
  624.             v = *pptr;
  625.             v = v - ((v - 128) >> 2);
  626.             *pptr++ = v;
  627.  
  628.             v = *pptr;
  629.             v = v - ((v - 128) >> 2);
  630.             *pptr++ = v;
  631.  
  632.             v = *pptr;
  633.             v = v - ((v - 128) >> 2);
  634.             *pptr++ = v;
  635.         }
  636.     }
  637.     InvalRect_ImageWindow(true);
  638. } // reduce_contrast
  639.  
  640.  
  641. // ==============================================
  642. // Increase the contrast of every pixel value in image window a bit
  643. void increase_contrast(void)
  644. {
  645.     unsigned char *pptr;
  646.     long i,j;
  647.     short v;
  648.  
  649.     make_undo();
  650.     if (gImagePixmapPtr == 0) return;
  651.  
  652.     for (i=0; i < gImageHeight; i++)
  653.     {
  654.         for (j=0; j < gImageWidth; j++)
  655.         {
  656.             pptr = (unsigned char *) 
  657.                     (gImagePixmapPtr + 4L * ((gImageWidth * i) + j));
  658.             *pptr++ = 0;
  659.  
  660.             v = *pptr;
  661.             v = v + ((v - 128) >> 2);
  662.             *pptr++ = ClipToByteRange(v);
  663.  
  664.             v = *pptr;
  665.             v = v + ((v - 128) >> 2);
  666.             *pptr++ = ClipToByteRange(v);
  667.  
  668.             v = *pptr;
  669.             v = v + ((v - 128) >> 2);
  670.             *pptr++ = ClipToByteRange(v);
  671.         }
  672.     }
  673.     InvalRect_ImageWindow(true);
  674. } // increase_contrast
  675.  
  676.  
  677. // ==============================================
  678. // draw a 1 pixel black border around the edge of the image
  679. void draw_border(void)
  680. {
  681.     unsigned char *pptr;
  682.     long i;
  683.     
  684.     make_undo();
  685.     if (gImagePixmapPtr == 0) return;
  686.  
  687.     for (i=0; i < gImageHeight; i++)
  688.     {
  689. /* left border edge */
  690.             pptr = (unsigned char *) 
  691.                     (gImagePixmapPtr + (gImageWidth * 4 * i) );
  692.             *pptr++ = 0;
  693.             *pptr++ = 0;
  694.             *pptr++ = 0;
  695.             *pptr++ = 0;
  696.  
  697. /* right border edge */
  698.             pptr = (unsigned char *) 
  699.                     (gImagePixmapPtr + (gImageWidth * 4 * i) + ((gImageWidth-1) * 4) );
  700.             *pptr++ = 0;
  701.             *pptr++ = 0;
  702.             *pptr++ = 0;
  703.             *pptr++ = 0;
  704.     }
  705.     for (i=0; i < gImageWidth; i++)
  706.     {
  707. /* top border edge */
  708.             pptr = (unsigned char *) 
  709.                     (gImagePixmapPtr + (4 * i));
  710.             *pptr++ = 0;
  711.             *pptr++ = 0;
  712.             *pptr++ = 0;
  713.             *pptr++ = 0;
  714.  
  715. /* bottom border edge */
  716.             pptr = (unsigned char *) 
  717.                     ( gImagePixmapPtr + 4L*gImageWidth*(gImageHeight-1) + 4*i );
  718.             *pptr++ = 0;
  719.             *pptr++ = 0;
  720.             *pptr++ = 0;
  721.             *pptr++ = 0;
  722.  
  723.     }
  724.     InvalRect_ImageWindow(true);
  725. } // draw_border
  726.  
  727.  
  728. // ==============================================
  729. // Create and open the virtual image buffer file for large images
  730. void open_virtual(void)
  731. {
  732.     int err;
  733.  
  734.     delete_virtual();
  735.     if (!gDoingVirtualFile)
  736.     {
  737.         gVirtualImageFile = fopen(POVRAY_IMAGETEMP_FNAME,"wb+");
  738.         err = ferror(gVirtualImageFile);
  739.         if (!gVirtualImageFile)
  740.             printf("## Error #%d opening file '%s'!\n", err, POVRAY_IMAGETEMP_FNAME);
  741.     }
  742.     virtual_currentSegment = -1;
  743.     virtual_buffer_dirty = false;
  744.     virtual_minY = 32767;
  745.     virtual_maxY = 0;
  746.     virtual_pixHeight = virtual_segSize / (gImageWidth * 4L);
  747.     gDoingVirtualFile = true;
  748. } // open_virtual
  749.  
  750.  
  751. // ==============================================
  752. // Close and delete the virtual image buffer file
  753. void delete_virtual(void)
  754. {
  755.     int k;
  756.     if (gDoingVirtualFile)
  757.     {
  758.         fclose (gVirtualImageFile);
  759.         gVirtualImageFile = NULL;
  760.     }
  761.     k = remove(POVRAY_IMAGETEMP_FNAME);
  762.     gDoingVirtualFile = false;
  763. } // delete_virtual
  764.  
  765.  
  766. // ==============================================
  767. // Dispose of virtual image buffer memory, and close/delete the file
  768. void dispose_virtual(void)
  769. {
  770.     Handle h;
  771.  
  772.     if (gImagePixmapPtr)
  773.     {
  774.         h = RecoverHandle(gImagePixmapPtr);
  775.         HUnlock(h);
  776.         DisposHandle(h);
  777.         gImagePixmapPtr = NULL;
  778.         gCanUndo = 0;
  779.     }
  780.  
  781.     if (gImageUndoBuffer)
  782.         DisposePtr(gImageUndoBuffer);
  783.     if (gImageUndoBuffer2)
  784.         DisposePtr(gImageUndoBuffer2);
  785.     if (gImageRevertBuffer)
  786.         DisposePtr(gImageRevertBuffer);
  787.     gImageUndoBuffer = NULL;
  788.     gImageUndoBuffer2 = NULL;
  789.     gImageRevertBuffer = NULL;
  790.  
  791.     delete_virtual();
  792.     virtual_minY = 32767;
  793. } // dispose_virtual
  794.  
  795.  
  796. // ==============================================
  797. // swap in the "y"th virtual image buffer segment from disk
  798. void swap_virtual_segment (short y)
  799. {
  800.     int i;
  801.     int err;
  802.         
  803.     // is Y outside currently loaded segment? need to load new one
  804.     if (gDoingVirtualFile && ((y < virtual_minY) || (y >= virtual_maxY)) )
  805.     {
  806.         // is current segment dirty? save to disk first if so
  807.         if (virtual_buffer_dirty && (virtual_currentSegment >= 0))
  808.         {
  809.             fseek(gVirtualImageFile, (virtual_currentSegment * virtual_segSize), SEEK_SET);
  810.             if ( fwrite((char *) gImagePixmapPtr, virtual_segSize, 1, gVirtualImageFile) != 1)
  811.             {    // error
  812.                 err = ferror(gVirtualImageFile);
  813.                 if (err)
  814.                     printf("## Error #%d writing position #%ld in file '%s'!\n",
  815.                             err, (virtual_currentSegment * virtual_segSize),
  816.                             POVRAY_IMAGETEMP_FNAME);
  817.                 dispose_virtual();
  818.             }
  819.         }
  820.  
  821.         // Now calculate and read needed segment into memory
  822.         if (gDoingVirtualFile)
  823.         {
  824.             // calculate new current segment stuff
  825.             virtual_currentSegment = (int) (y / virtual_pixHeight);
  826.             virtual_minY = virtual_currentSegment * virtual_pixHeight;
  827.             virtual_maxY = (virtual_currentSegment + 1) * virtual_pixHeight;
  828.  
  829.             // read it in off disk
  830.             fseek(gVirtualImageFile, (virtual_currentSegment * virtual_segSize), SEEK_SET);
  831.             i = fread((char *) gImagePixmapPtr, virtual_segSize, 1, gVirtualImageFile);
  832.             err = ferror(gVirtualImageFile);
  833.             if (err)
  834.                 printf("## Error #%d reading position #%ld in file '%s'!\n",
  835.                         err, (virtual_currentSegment * virtual_segSize),
  836.                         POVRAY_IMAGETEMP_FNAME);
  837.             virtual_buffer_dirty = false;
  838.         }
  839.  
  840.         // error.. couldn't keep swap file open
  841.         if (!gDoingVirtualFile)
  842.             (void)displayDialog(139, NULL, 0, ewcDoCentering, eSameAsPassedWindow);
  843.     }
  844.  
  845. } // swap_virtual_segment
  846.  
  847.  
  848. // ==============================================
  849. // Initialize the display, set up buffers (VIB if needed)
  850. void display_init(int width, int height)
  851. {
  852.     long        *p, *q, pmsize, i;
  853.     Handle        h;
  854.     short        error_dlogID = 0;
  855.     DialogPtr    progressDialogPtr = NULL;
  856.  
  857.     if ((**gPrefs2Use_h).progress >= kProgMinimal)
  858.     {
  859.         printf("-- [Memory]  FreeMemory=%ldK\n", FreeMem()/1024L);
  860.     }
  861.  
  862.     SetCursor(&gWaitCursor); // could take a little while..
  863.  
  864.     gImageWidth = width;
  865.     gImageHeight = height;
  866.     gPixMapBuffSize = 4L * (long) width * (long) height;
  867.     gCurrYPos = 0;
  868.     gLastYPos = 0;
  869.  
  870.     SetRect(&gImageBounds, 0, 0, width, height);
  871.     pmsize = gPixMapBuffSize;
  872.  
  873.     virtual_buffer_dirty = false;
  874.  
  875.     h = NULL;
  876.     // if there is enough room for a pixmap, plus a little free space (100KB),
  877.     // then go ahead and allocate it..
  878.     if    (FreeMem() > pmsize + 100000L)
  879.         h = NewHandleClear(pmsize);
  880.  
  881.     // ..otherwise play virtual buffer games..
  882.     if (h == NULL)
  883.     {
  884.         // can't allocate, do it in segments, set up progress dialog
  885.         progressDialogPtr = GetNewProgressDialog(153, 3);
  886.         if (progressDialogPtr)
  887.         {
  888.             PositionWindow(progressDialogPtr, ewcDoCentering, eSameAsPassedWindow, (WindowPtr)gp2wWindow);
  889.             ShowWindow(progressDialogPtr);
  890.             SelectWindow(progressDialogPtr);
  891.             DrawDialog(progressDialogPtr);
  892.             // make sure events get through so dlog is updated
  893.             Cooperate(true);
  894.         }
  895.     }
  896.  
  897.     // let user know some info
  898.     if ((**gPrefs2Use_h).progress >= kProgMinimal)
  899.     {
  900.         if ( (h == NULL) && ((**gPrefs2Use_h).progress >= kProgDebug) )
  901.             printf("-d VIBNumSegments=%d, VIBSegmentSize=%dK\n",
  902.                     (int)1+(gImageHeight / (virtual_segSize / (gImageWidth * 4L))),
  903.                     (int)(virtual_segSize/1024L));
  904.         printf("-- ImageBufferPixWidth=%d, ImageBufferPixHeight=%d, ImageBufferSize=%ldK\n",
  905.             gImageWidth, gImageHeight, pmsize/1024L);
  906.     }
  907.  
  908.     if (h)
  909.     { // got whole thing, initialize it
  910.         MoveHHi(h);
  911.         HLock(h);
  912.         gImagePixmapPtr = *h;
  913.         (*gOffScreenPixMapH)->bounds = gImageBounds;
  914.         (*gOffScreenPixMapH)->rowBytes = (width * 4) | 0x8000;
  915.         (*gOffScreenPixMapH)->baseAddr = gImagePixmapPtr;
  916.         // fill to white
  917.         q = (long *) ((long) gImagePixmapPtr + pmsize);
  918.         for (p = (long *) gImagePixmapPtr; p < q; *p++ = -1L)
  919.             ;
  920.         gDitherTicks = 20*60;    /* 20 seconds between re-dithers */
  921.     }
  922.     else
  923.     { // set up the virtual buffer
  924.  
  925.         open_virtual();
  926.         SetRect(&gImageBounds, 0, 0, width, virtual_pixHeight);
  927.  
  928.         if (gDoingVirtualFile)
  929.             h = NewHandleClear(virtual_segSize);
  930.  
  931.         if (!h)
  932.         {
  933.             dispose_virtual();
  934.             error_dlogID = 133; // no display memory
  935.         }
  936.         else
  937.         {
  938.             if (progressDialogPtr)
  939.                 updateProgressDialog(progressDialogPtr, 0, gImageHeight-1, 1);
  940.             MoveHHi(h);
  941.             HLock(h);
  942.             gImagePixmapPtr = *h;
  943.             (*gOffScreenPixMapH)->bounds = gImageBounds;
  944.             (*gOffScreenPixMapH)->rowBytes = (width * 4) | 0x8000;
  945.             (*gOffScreenPixMapH)->baseAddr = gImagePixmapPtr;
  946.             // fill to white
  947.             q = (long *) ((long) gImagePixmapPtr + virtual_segSize);
  948.             for (p = (long *) gImagePixmapPtr; p < q; *p++ = -1)
  949.                 ;
  950.             gDitherTicks = 4L*60L*60L;    /* 4 minutes between re-dithers */
  951.  
  952.             // We go through this for loop with i stepping down through the image
  953.             // scanlines every 1/2 buffer size.  The only reason for not going
  954.             // every buffer size (virtual_pixHeight) is to make the progress bar
  955.             // a little less jerky, doesn't slow things down much.
  956.             for (i=0; (i<gImageHeight)&&gDoingVirtualFile; i+=(virtual_pixHeight>>1))
  957.             {
  958.                 // Update the progress bar
  959.                 if (progressDialogPtr)
  960.                 {
  961.                     Cooperate(true);
  962.                     updateProgressDialog(progressDialogPtr, 0, gImageHeight-1, i);
  963.                 }
  964.                 // force it to write each segment to disk to build the file
  965.                 virtual_buffer_dirty = true;
  966.                 swap_virtual_segment (i);
  967.             }
  968.  
  969.             /* swap back in segment 0 */
  970.             if (gDoingVirtualFile)
  971.             {
  972.                 if (progressDialogPtr)
  973.                     updateProgressDialog(progressDialogPtr, 0, gImageHeight, gImageHeight);
  974.                 virtual_buffer_dirty = true;
  975.                 swap_virtual_segment(0);
  976.             }
  977.  
  978.             if (!gDoingVirtualFile)
  979.             {
  980.                 error_dlogID = 139; // no disk space for swap file
  981.                 dispose_virtual();
  982.             }
  983.         }
  984.  
  985.         SetCursor(&qd.arrow);
  986.  
  987.         // get rid of progress dialog
  988.         if (progressDialogPtr)
  989.             disposeProgressDialog(progressDialogPtr);
  990.  
  991.     } // else virtual
  992.  
  993.     // display any error messages now
  994.     if (error_dlogID)
  995.         (void)displayDialog(error_dlogID, NULL, 0, ewcDoCentering, eSameAsPassedWindow);
  996.     else
  997.     {
  998.         // image window now has content
  999.         // turn on now, so SetImageWindMag will show window
  1000.         gImageWindIsValid = true;
  1001.  
  1002.         // size and show the window
  1003.         SetImageWindowMag((**gPrefs2Use_h).imageMagFactor);
  1004.  
  1005.         if (gHasPictUtils)
  1006.             SetCustomPalette(false);
  1007.     }
  1008.  
  1009.     SetCursor(&qd.arrow); // all done initializing..
  1010. } // display_init
  1011.  
  1012.  
  1013. // ==============================================
  1014. // Plot a single pixel at (x,y)
  1015. void display_plot(int x, int y, 
  1016.                      unsigned char Red,
  1017.                      unsigned char Green,
  1018.                      unsigned char Blue)
  1019. {
  1020.     RGBColor c;
  1021.     unsigned char *pptr;
  1022.     Rect    magniRect;
  1023.     long    pport_y;
  1024.     int        mr;
  1025.     int        magFactor;
  1026.  
  1027.     gCurrYPos = y;
  1028.  
  1029.     if (gImagePixmapPtr)
  1030.     {
  1031.         if (gDoingVirtualFile)
  1032.         {
  1033.             swap_virtual_segment(y);
  1034.             pport_y = y - virtual_minY;        /* Y offset within current virtual segment */
  1035.             virtual_buffer_dirty = true;
  1036.         }
  1037.         else
  1038.             pport_y = y;
  1039.  
  1040.         // slam the RGB value into the pixmap
  1041.         pptr = (unsigned char *) 
  1042.                 ((long) gImagePixmapPtr + 4L * ((long) gImageBounds.right * pport_y + (long) x));
  1043.         *pptr++    = 0;
  1044.         *pptr++    = Red;
  1045.         *pptr++    = Green;
  1046.         *pptr    = Blue;
  1047.     }
  1048.  
  1049.     magFactor = (**gPrefs2Use_h).imageMagFactor;
  1050.     if (magFactor != viewmn_hidden)
  1051.     { // it is visible
  1052.         SetPort(gImageWindowPtr);
  1053.         c.red = ((short)Red)<<8;
  1054.         c.green = ((short) Green)<<8;
  1055.         c.blue = ((short) Blue)<<8;
  1056.         if (magFactor == viewmn_normal)
  1057.             SetCPixel(x, y, &c);
  1058.         else
  1059.         { // some magnification at play here
  1060.             if (magFactor != viewmn_Size2Window)
  1061.             { // go to straight magnification N (don't display
  1062.                 magFactor = magFactor-viewmn_normal+1; // 2,3,4
  1063.                 mr = gCurrYPos * magFactor;
  1064.                 magniRect.top        = mr;
  1065.                 magniRect.bottom    = mr + magFactor;
  1066.                 magniRect.left        = x * magFactor;
  1067.                 magniRect.right        = (x+1) * magFactor;
  1068.                 RGBForeColor(&c);
  1069.                 PaintRect(&magniRect);
  1070.             }
  1071.         }
  1072.  
  1073.         // time to update the image?
  1074.         if (TICKS > (gRefreshTick + gDitherTicks))
  1075.         {
  1076.             if (y > (gLastYPos + 1))
  1077.             {
  1078.                 InvalRect_ImageWindow(false);
  1079.                 Cooperate(true);
  1080.                 gLastYPos = y;
  1081.                 gRefreshTick = TICKS;
  1082.             }
  1083.         }
  1084.  
  1085.     }
  1086. } // display_plot
  1087.  
  1088.  
  1089. // ==============================================
  1090. // Do any cleanup needed when the display is complete
  1091. void display_finished(void)
  1092. {
  1093.     // Reset last Y pos so that screen refreshes do the whole screen
  1094.     gLastYPos = 0;
  1095. } // display_finished
  1096.  
  1097.  
  1098. // ==============================================
  1099. // Close any files used after display is complete
  1100. void display_close(void)
  1101. {
  1102. } // display_close
  1103.  
  1104.  
  1105. // ==============================================
  1106. // Find and assign the appropriate custom palette to the image window
  1107. void SetCustomPalette(Boolean doScreenUpdate)
  1108. {
  1109.     PictInfo        plot_info;
  1110.     short            k;
  1111.     OSErr            anError = noErr;
  1112.     PaletteHandle    thePalette = NULL;
  1113.  
  1114.     if (gImageWindowPtr)
  1115.         SetPort(gImageWindowPtr);
  1116.  
  1117.     if (gHasPictUtils && use_custom_palette && gOffScreenPixMapH)
  1118.     {
  1119.         switch(gColorQuantMethod)
  1120.         {
  1121.             case systemMethod:
  1122.             case popularMethod:
  1123.             case medianMethod:
  1124.                 anError = GetPixMapInfo(gOffScreenPixMapH,
  1125.                                 &plot_info,
  1126.                                 returnPalette + suppressBlackAndWhite,
  1127.                                 256,
  1128.                                 gColorQuantMethod,
  1129.                                 0);
  1130.  
  1131.                 // copy the new palette entries into custom palette & use it
  1132.                 if (plot_info.thePalette && gCustomPalette)
  1133.                 {
  1134.                     CopyPalette(plot_info.thePalette, gCustomPalette, 0, 0, 256);
  1135.                     for (k=0; k<256; k++)
  1136.                         SetEntryUsage(gCustomPalette, k, pmTolerant, 0x0000);
  1137.                     thePalette = gCustomPalette;
  1138.                 }
  1139.                 // done with retrieved palette. toolbox created it, so we must destroy it!
  1140.                 if (plot_info.thePalette)
  1141.                     DisposePalette(plot_info.thePalette);
  1142.                 break;
  1143.             otherwise:
  1144.                 SysBeep(4);
  1145.                 break;
  1146.         }
  1147.     }
  1148.     else
  1149.     {
  1150.         // Revert to system palette
  1151.         thePalette = gSystemPalette;
  1152.     }
  1153.  
  1154.     if (gImageWindowPtr)
  1155.     {
  1156.         // reset all screens, this is a little severe though!
  1157.         if (doScreenUpdate)
  1158.             RestoreDeviceClut(NULL);
  1159.         // tell window to use the new palette
  1160.         if (thePalette)
  1161.             NSetPalette(gImageWindowPtr, thePalette, pmAllUpdates);
  1162.         ActivatePalette(gImageWindowPtr);
  1163.     }
  1164.  
  1165. } // SetCustomPalette
  1166.  
  1167.  
  1168. // ==============================================
  1169. // Display the image to the window
  1170. void DrawImageWindow(Boolean DoWholeWindow)
  1171. {
  1172.     BitMap        bmap;
  1173.     short         myMode, i;
  1174.     int            magFactor;
  1175.     static short counter = 0;
  1176.     Rect        my_bounds;
  1177.     RGBColor    myRGBWhite = {-1,-1,-1};
  1178.     RGBColor    myRGBBlack = {0,0,0};
  1179.  
  1180.  
  1181.     SetCursor(&gWaitCursor); // could take a little while..
  1182.  
  1183.     magFactor = (**gPrefs2Use_h).imageMagFactor;
  1184.     if (magFactor != viewmn_hidden)
  1185.     { // it is visible
  1186.         // set these to defaults so copybits behaves predictably
  1187.         RGBBackColor(&myRGBWhite);
  1188.         RGBForeColor(&myRGBBlack);
  1189.  
  1190.         if (DoWholeWindow)
  1191.         {
  1192.             // clear whole window
  1193.             EraseRect(&gImageWindowPtr->portRect);
  1194.         }
  1195.         else
  1196.         {
  1197.         }
  1198.  
  1199.         // something to display?
  1200.         if (gImagePixmapPtr)
  1201.         {
  1202.             bmap.baseAddr = (Ptr) gOffScreenPixMapH;
  1203.             bmap.rowBytes = 0xC000;
  1204.             bmap.bounds = gImageBounds;
  1205.  
  1206. //            if (gHasPictUtils)
  1207. //                SetCustomPalette(false);
  1208.  
  1209.             if ((**gPrefs2Use_h).doDither)
  1210.                 myMode = ditherCopy;
  1211.             else
  1212.                 myMode = srcCopy;
  1213.  
  1214.             if (gDoingVirtualFile)
  1215.             {
  1216.                 magFactor = magFactor-viewmn_normal+1; // 1,2,3,4
  1217.                 for (i=0; i < gImageHeight; i = i + virtual_pixHeight)
  1218.                 {
  1219.                     swap_virtual_segment (i);
  1220.                     my_bounds = gImageBounds;
  1221. // <esp> need to fix up for magFactor in virtual mode
  1222.                     my_bounds.top = (i * magFactor);
  1223.                     my_bounds.bottom = my_bounds.top + (virtual_pixHeight * magFactor);
  1224.                     /* don't worry about the bounds, the clipping region
  1225.                     of the window will stop us from drawing past the bottom */                    
  1226.                     my_bounds.left = 0;
  1227.                     my_bounds.right = gImageWidth * magFactor;
  1228.                     CopyBits(&bmap, &gImageWindowPtr->portBits,
  1229.                                     &gImageBounds, &my_bounds,
  1230.                                     myMode, NULL);
  1231.                 }
  1232.             }
  1233.             else
  1234.             {
  1235.                 CopyBits(&bmap, &gImageWindowPtr->portBits,
  1236.                                 &gImageBounds, &gDisplayBounds,
  1237.                                 myMode, NULL);
  1238.             }
  1239.  
  1240.             // Draw our custom size box if in Size-2-Window mode
  1241.             if (magFactor == viewmn_Size2Window)
  1242.                 DrawImageGrowBox();
  1243.  
  1244.         } // offscreen exists
  1245.      } // it is visible
  1246.  
  1247.     SetCursor(&qd.arrow);
  1248.  
  1249. } // DrawImageWindow
  1250.  
  1251.  
  1252. // ==============================================
  1253. // Write Picture bottleneck routine for paint_to_picture()
  1254. CALLBACK(pascal void, uppQDPutPicProcInfo, MyPutPicProc)( char *dataPtr, short byteCount)
  1255. {
  1256.     int myByteCount;
  1257.  
  1258.     myByteCount = byteCount;
  1259.     gMyPicSize += byteCount;
  1260.     if (gImagePictFile)
  1261.     {
  1262.         if (fwrite( dataPtr, 1, myByteCount, gImagePictFile) != myByteCount)
  1263.         {
  1264.             fclose (gImagePictFile);
  1265.             gImagePictFile = 0;
  1266.         }
  1267.     }
  1268.     // we have to keep the picture handle header updated for Quickdraw!
  1269.     if (gMyPicHandle)
  1270.         (**gMyPicHandle).picSize = gMyPicSize;
  1271. } // MyPutPicProc
  1272.  
  1273.  
  1274. // ==============================================
  1275. // Write the Pixmap out to either a disk file, or the Clipboard
  1276. void paint_to_picture(short do_disk_buffer)
  1277. {
  1278.     BitMap        bmap;
  1279.     short         myMode, i;
  1280.     OSErr        anError;
  1281.     Rect        my_bounds, myPicRect;    
  1282.     CGrafPort    myCGrafPtr;
  1283.     GrafPtr        oldGrafPtr;
  1284.     PictFHeader    myPictFHeader;
  1285.     CQDProcs    myQDProcs;
  1286.  
  1287.     anError = noErr;
  1288.     if (gImagePixmapPtr)
  1289.     {
  1290.         SetCursor(&gWaitCursor); // could take a little while..
  1291.  
  1292.         GetPort(&oldGrafPtr);
  1293.         OpenCPort (&myCGrafPtr);
  1294.         SetPort ((GrafPtr)&myCGrafPtr);
  1295.  
  1296.         PortSize (gImageWidth, gImageHeight);
  1297.         myPicRect.top = 0;
  1298.         myPicRect.bottom = gImageHeight;
  1299.         myPicRect.left = 0;
  1300.         myPicRect.right = gImageWidth;
  1301.  
  1302.         ClipRect(&myPicRect);
  1303.  
  1304.         if (do_disk_buffer)
  1305.         {
  1306.             SetStdCProcs ((CQDProcsPtr) &myQDProcs);
  1307.             myQDProcs.putPicProc = (QDPutPicUPP)&MyPutPicProc;
  1308.             myCGrafPtr.grafProcs = (CQDProcsPtr) &myQDProcs;
  1309.             // write the PICT header to the file
  1310.             gMyPicSize = sizeof(myPictFHeader);
  1311.             myPictFHeader.picSize = gMyPicSize; // accumulated later in MyPutPicProc()..
  1312.             myPictFHeader.picFrame = myPicRect;
  1313.             i = fwrite (&myPictFHeader, 1, sizeof(myPictFHeader), gImagePictFile);
  1314.             anError = ferror(gImagePictFile);
  1315.         }
  1316.  
  1317.         if (!anError)
  1318.         {
  1319.             /* insure gMyPicHandle null, 'cause MyPutPicProc will be called in OpenPicture! */
  1320.             gMyPicHandle = NULL;
  1321.             gMyPicHandle = OpenPicture (&myPicRect);
  1322.             anError = QDError();
  1323.         }
  1324.  
  1325.         bmap.baseAddr = (Ptr) gOffScreenPixMapH;
  1326.         bmap.rowBytes = 0xC000;    // flag for PixMap
  1327.         if ((**gPrefs2Use_h).doDither)
  1328.             myMode = ditherCopy;
  1329.         else
  1330.             myMode = srcCopy;
  1331.  
  1332.         if (!anError)
  1333.         {
  1334.             if (gDoingVirtualFile)
  1335.                 for (i=0; (i <= gImageHeight) && !anError; i = i + virtual_pixHeight)
  1336.                 {
  1337.                     swap_virtual_segment (i);
  1338.                     my_bounds.top = i;
  1339. // NOTE, JIM! (next source line)
  1340. // By doing a CopyBits of the last rect in full, the whole rect of pixels _does_
  1341. // get written to the PICT file, even though not all the scan lines are valid..
  1342. // this doesn't hurt anything, just makes the file a little bigger than it needs to be,
  1343. // since the extra lines will get clipped on playback.  However, since gImageBounds is
  1344. // global, it would be icky to temporarily change its bottom along with my_bounds so
  1345. // as to only write the necessary lines.. maybe later. :-)
  1346.                     my_bounds.bottom = i + virtual_pixHeight;
  1347.                     my_bounds.left = 0;
  1348.                     my_bounds.right = gImageWidth;
  1349.                     CopyBits(&bmap, (BitMap *)&myCGrafPtr.portPixMap, &gImageBounds, &my_bounds,
  1350.                              myMode, NULL);
  1351.                     anError = QDError();
  1352.                 }
  1353.             else
  1354.                 {
  1355.                 CopyBits(&bmap, (BitMap *)&myCGrafPtr.portPixMap, &gImageBounds, &gImageBounds,
  1356.                          myMode, NULL);
  1357.                 anError = QDError();
  1358.                 }
  1359.         }
  1360.  
  1361.         /* write end-of-picture */
  1362.         if (!anError)
  1363.         {
  1364.             ClosePicture();
  1365.             anError = QDError();
  1366.         }
  1367.  
  1368.         if (!anError)
  1369.         {
  1370.             if (do_disk_buffer)
  1371.             {
  1372.                 /* don't call us anymore! */
  1373.                 SetStdCProcs((CQDProcsPtr) &myQDProcs);
  1374.  
  1375.                 /* move back to pic header again */
  1376.                 fflush(gImagePictFile);
  1377.                 fseek(gImagePictFile, PICTF_HEADER_SIZE, SEEK_SET);
  1378.                 anError = ferror(gImagePictFile);
  1379.                 /* update the PICT header in the file (with now-true picSize field..) */
  1380.                 if (!anError)
  1381.                 {
  1382.                     myPictFHeader.picSize = gMyPicSize;
  1383.                     i = fwrite (&myPictFHeader, 1, sizeof(myPictFHeader), gImagePictFile);
  1384.                     anError = ferror(gImagePictFile);
  1385.                 }
  1386.             }
  1387.             else
  1388.             {
  1389.                 ZeroScrap();
  1390.                 HLock((Handle) gMyPicHandle);
  1391.                 gMyPicSize = GetHandleSize((Handle) gMyPicHandle);
  1392.                 PutScrap (gMyPicSize, 'PICT', (Ptr) *gMyPicHandle);
  1393.                 gMyPicSize = UnloadScrap();
  1394.                 HUnlock((Handle) gMyPicHandle);
  1395.             }
  1396.         } // if !error
  1397.  
  1398.         /* close up shop */
  1399.         CloseCPort(&myCGrafPtr);
  1400.         SetPort(oldGrafPtr);
  1401.         if (gMyPicHandle)
  1402.             DisposeHandle((Handle) gMyPicHandle);
  1403.  
  1404.         /* oh yeah, check for errors */
  1405.         if (anError)
  1406.         {
  1407.             if (gImagePictFile)
  1408.             {
  1409.                 fclose (gImagePictFile);
  1410.                 gImagePictFile = NULL;
  1411.             }
  1412.             SysBeep(4);
  1413.         }
  1414.  
  1415.         SetCursor(&qd.arrow);
  1416.  
  1417.     } // if gImagePixmapPtr..
  1418. } // paint_to_picture
  1419.  
  1420.  
  1421. // ==============================================
  1422. // Write the Pixmap as a PICT file
  1423. // getName - if true, prompt for output file name
  1424. // animSuffix - ignore if <0, if 0-N then use as file name frame suffix for anim
  1425. // ci - QuickTime StdCompression component if image is to be compressed
  1426. void SaveOutputFile(Boolean getName, int animSuffix, ComponentInstance ci)
  1427. {
  1428.     int         k;
  1429.     Rect        myPicRect;    
  1430.     Point         where;
  1431.     SFReply        reply;
  1432.     FInfo        myFileInfo;
  1433.     FSSpec        fsFile;        
  1434.     char        filler[4];
  1435.     char        cFname[256];
  1436.  
  1437.     for (k=0; k<4; k++)
  1438.         filler[k] = 0;
  1439.  
  1440.     // Find and remove the ".POV" suffix
  1441.     pStrCopy(gSrcWind_FileName, (StringPtr)cFname);
  1442.     p2cstr((StringPtr)cFname);
  1443.     k = strlen(cFname);
  1444.     if ((k>4) && (cFname[k-4] == '.'))
  1445.         cFname[k-4] = '\0';
  1446.  
  1447.     // add animation suffix?
  1448.     strcat (cFname, ".");
  1449.     if (animSuffix == kNoAnimSuffix)
  1450.     {
  1451.         strcat (cFname, "Pict");
  1452.     }
  1453.     else
  1454.     {
  1455.         sprintf(filler, "%03d",animSuffix);
  1456.         strcat (cFname, filler);
  1457.     }
  1458.  
  1459.     if (getName)
  1460.     {
  1461.         c2pstr(cFname);
  1462.  
  1463.         GetBestDialogPos(&where);
  1464.         SFPutFile (where, "\pSave PICT file as╔", (StringPtr)cFname, NULL, &reply);
  1465.     }
  1466.     else
  1467.     {
  1468.         // copy the generated name into SF Reply..
  1469.         strcpy ((char *) reply.fName,cFname);
  1470.         c2pstr((char *)reply.fName);
  1471.         reply.vRefNum = gSrcWind_VRefNum;
  1472.         reply.good = TRUE;
  1473.     }
  1474.  
  1475.     if (reply.good)
  1476.     {
  1477.         SetCursor(&gWaitCursor);
  1478.  
  1479.         fsFile.vRefNum = reply.vRefNum;
  1480.         fsFile.parID = 0;
  1481.         BlockMove(reply.fName, fsFile.name, 1+reply.fName[0]);
  1482.  
  1483.         p2cstr(reply.fName);
  1484.         SetVol(NULL, reply.vRefNum);
  1485.         gImagePictFile = fopen((char *) reply.fName,"wb");
  1486.         if (gImagePictFile)
  1487.         {
  1488.             for (k=0; k<PICTF_HEADER_SIZE/4; k++)
  1489.                 fwrite (&filler, 1, 4, gImagePictFile);
  1490.  
  1491.             // if not doing a virtual screen (which could take awhile) then
  1492.             // let the window update event get through to repaint the image
  1493.             // in case the dialog stomped on it.
  1494.             if (!gDoingVirtualFile)
  1495.             {
  1496.                 Cooperate(true);
  1497.             }
  1498.  
  1499.             paint_to_picture(TRUE);
  1500.  
  1501.             if (gImagePictFile)
  1502.                 {
  1503.                     fclose (gImagePictFile);
  1504.                     gImagePictFile = NULL;
  1505.                     c2pstr((char *)reply.fName);
  1506.  
  1507.                     /* If QuickTime is around & user wants to squish the picture, ask user how to squish it */
  1508.                     if (gHasImageCompressionMgr && (**gPrefs2Use_h).doCompression)
  1509.                     {
  1510.                         myPicRect.top = 0;
  1511.                         myPicRect.bottom = gImageHeight;
  1512.                         myPicRect.left = 0;
  1513.                         myPicRect.right = gImageWidth;
  1514.                         k = FSMakeFSSpec(reply.vRefNum, 0, reply.fName, &fsFile);
  1515.  
  1516.                         if (!k)
  1517.                             k=CompressPictF(ci, &fsFile);
  1518.                     }
  1519.  
  1520.                     // set image file to type PICT
  1521.                     k = GetFInfo(reply.fName, reply.vRefNum, &myFileInfo);
  1522.                     if (k==0)
  1523.                     {
  1524.                         myFileInfo.fdType = 'PICT';
  1525.                         myFileInfo.fdCreator = (**gPrefs2Use_h).pictFileCreator;
  1526.                         k = SetFInfo (reply.fName, reply.vRefNum, &myFileInfo);
  1527.                     }
  1528.  
  1529. // not yet tested and working, but leave in for later..
  1530. //                    // stick a preview resource on it
  1531. //                    if (wanted..)
  1532. //                        k = AppendFilePreview2PictF(&fsFile);
  1533.  
  1534.                     // Add System 7 custom icons of the image itself to the file
  1535.                     if (gHasImageCompressionMgr)
  1536.                         AppendFinderIcons2PictF(&fsFile, &myPicRect, eAFI_ShrinkWholeImage);
  1537.                 }
  1538.             else
  1539.                 // couldn't write PICT file
  1540.                 (void)displayDialog(140, NULL, 0, ewcDoCentering, eSameAsPassedWindow);
  1541.         }
  1542.         SetCursor(&qd.arrow);
  1543.     }
  1544. } // SaveOutputFile
  1545.